home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / oper_sys / choices / chcssml1.lha / Job.c < prev    next >
C/C++ Source or Header  |  1989-02-06  |  4KB  |  136 lines
  1. /*
  2.  * This file is part of the Choices Operating System Simulator
  3.  * Developed by: The TAPESTRY Parallel Computing Laboratory
  4.  *         University of Illinois at Urbana-Champaign
  5.  *         Department of Computer Science
  6.  *         1304 W. Springfield Ave.
  7.  *         Urbana, IL    61801
  8.  *
  9.  * Copyright (c) 1987, 1988, 1989 The University of Illinois Board of Trustees.
  10.  *    All Rights Reserved.
  11.  * CONFIDENTIAL INFORMATION. Distribution restricted under license agreement.
  12.  *
  13.  * Author: Gary M. Johnston (johnston@cs.uiuc.edu)
  14.  * Project Manager and Principal Investigator: Roy Campbell (roy@cs.uiuc.edu)
  15.  *
  16.  * Funded by: NSF TAPESTRY Grant No. 1-5-30035, NASA ICLASS Grant 
  17.  *   No. 1-5-25469 and No. NSG1471 and AT&T Metronet Grant No. 1-5-37411.
  18.  */
  19. /*
  20.  * Job.c - Example work load.
  21.  *
  22.  * NOTE: Main() creates a Process whose entry point is Job(), below.
  23.  */
  24.  
  25. #include <stdio.h>
  26. #include "Choices.h"
  27. #include "Name.h"
  28. #include "Semaphore.h"
  29. #include "Pipe.h"
  30.  
  31. /* Create semaphores I need and give em names to help debugging*/
  32. Semaphore mutex_waitforsons(1, "mutex_waitforsons"), 
  33.         waitforsons(0,"waitforsons");
  34. int sons = 0;
  35. int maxprocesses = 0;
  36. Semaphore randmutex(1);
  37. extern int rand();
  38.  
  39. int 
  40. random(int u)
  41. { //In the range 1..u
  42.     randmutex.P();
  43.     int r = rand();
  44.     if (r < 0) r = -r;
  45.     randmutex.V();
  46.     return 1 + r%u ;
  47. };
  48.  
  49. struct Param
  50.     { int id;
  51.       Pipe * lpipe, * rpipe;
  52.     };
  53.  
  54.  
  55. int
  56. Sample(void * arg )
  57. {
  58.     Param * p = (Param *) arg;
  59.     int n = p->id;
  60.     Pipe * pipein = p->lpipe;
  61.     Pipe * pipeout = p->rpipe;
  62.     Assert(pipein != 0);
  63.     Assert(pipeout != 0);
  64.  
  65.     for (int i = 0; i<15; i++)
  66.         {
  67.         Message * message;
  68.         int choose = random(4);
  69.         Print("\njob %d: [clock %d] iteration %d\n", n, clock, i);
  70.         if (choose <= 2) 
  71.             { 
  72.               Print("Choice send\n");
  73.               if (message == 0)
  74.                   { message = new Message;
  75.                     message->value = i;
  76.                     message->destination = random(maxprocesses);
  77.                     message->source = n;
  78.                     Print("\nAbout to send a message to %d contents %d\n",
  79.                     message->destination,message->value);
  80.                 }
  81.               else Print("\nSending Message on\n");
  82.               if (choose == 1) pipeout->sendAndBlock(message);
  83.               else pipeout->send(message);
  84.             }
  85.         if ( choose >=2 ) 
  86.             { 
  87.               Print("\nChoice receive\n");
  88.               if (choose == 3 ) message=pipein->receiveAndBlock(); 
  89.               else message=pipein->receive();
  90.               if (message->destination==n) 
  91.                 { Print("\nReceived a message to %d contents %d\n",
  92.                   message->destination,message->value);
  93.                   message = 0;
  94.                 }
  95.             };
  96.         };
  97.     mutex_waitforsons.P();
  98.     /* decrement number of active sons.  if zero sons
  99.      * wake up manager.
  100.     */
  101.     if (--sons==0) waitforsons.V();
  102.     mutex_waitforsons.V();
  103.     Print("\nJob %d terminates\n", n);
  104.     return (0);
  105. }
  106.  
  107. int
  108. Job(void * argp)
  109. {
  110.     maxprocesses = (int) argp;
  111.     Pipe * pipearray[20];
  112.     Print("Job Manager Creates %d user processes\n", maxprocesses);
  113.     for (int i = 0; i < maxprocesses; i++) pipearray[i] = new Pipe();
  114.     for (i = 0; i < maxprocesses; i++)
  115.     {
  116.         /*  Create a user process */
  117.         Param * param = new Param;
  118.         param->id = i;
  119.         param->lpipe = pipearray[i];
  120.         param->rpipe = pipearray[(i+1)%maxprocesses];
  121.         Print("Address Pipe %d left. Pipe %d right\n",(int)param->lpipe, (int)param->rpipe);
  122.         Process * process = 
  123.             new Process(Sample, (void *) param);
  124.         /* Put the user process on the ready queue */
  125.         ThisCPU()->getScheduler()->add( process );
  126.         mutex_waitforsons.P();
  127.         sons++;
  128.         mutex_waitforsons.V();
  129.     };
  130.     Print("\nNew Job Manager waits for sons\n");
  131.     waitforsons.P(); /* wait for sons to finish */
  132.     Print("\nNew Job Manager terminates\n");
  133.     return(0);
  134. }
  135.  
  136.